package com.qf.common.utils;

import com.qf.common.enums.SignEnum;
import org.springframework.data.redis.connection.BitFieldSubCommands;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * 实现 RedisUtils2.setValue()
 */
public class RedisUtils {

    // 从容器中直接获取对应的RedisTemplate对象
    public static final RedisTemplate<String, Object> redisTemplate =
            SpringBeanUtils.getBean("redisTemplate");

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public static boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public static boolean expire(final String key, final long timeout, final TimeUnit unit) {
        Boolean ret = redisTemplate.expire(key, timeout, unit);
        return ret != null && ret;
    }

    /**
     * 删除单个key
     *
     * @param key 键
     * @return true=删除成功；false=删除失败
     */
    public static boolean delKey(final String key) {
        Boolean ret = redisTemplate.delete(key);
        return ret != null && ret;
    }

    /**
     * 删除多个key
     *
     * @param keys 键集合
     * @return 成功删除的个数
     */
    public static long delKeys(final Collection<String> keys) {
        Long ret = redisTemplate.delete(keys);
        return ret == null ? 0 : ret;
    }

    /**
     * 存入String数据
     *
     * @param key   Redis键
     * @param value 值
     */
    public static void setValue(final String key, final Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 存入String对象,设置超时时间
     *
     * @param key     键
     * @param value   值
     * @param timeout 有效期，单位秒
     */
    public static void setValueTimeout(final String key, final Object value, final long timeout) {
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 获取String对象
     *
     * @param key 键
     * @return 对象
     */
    public static Object getValue(final String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 确定哈希field是否存在
     *
     * @param key   键
     * @param field hash键
     * @return true=存在；false=不存在
     */
    public static boolean hasHashField(final String key, String field) {
        Boolean ret = redisTemplate.opsForHash().hasKey(key, field);
        return ret != null && ret;
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param field Hash键
     * @param value 值
     */
    public static void hashPut(final String key, final String field, final Object value) {
        redisTemplate.opsForHash().put(key, field, value);
    }

//    /**
//     * 往Hash中存入数据
//     *
//     * @param key   Redis键
//     * @param field Hash键
//     * @param value 值
//     */
//    public static Long hashIncr(final String key, final String field, long v) {
//       return redisTemplate.opsForHash().increment(key, field, v);
//    }


    /**
     * 往Hash中存入多个数据
     *
     * @param key    Redis键
     * @param values Hash键值对
     */
    public static void hashPutAll(final String key, final Map<String, Object> values) {
        redisTemplate.opsForHash().putAll(key, values);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key   Redis键
     * @param field Hash键
     * @return Hash中的对象
     */
    public static Object hashGet(final String key, final String field) {
        return redisTemplate.opsForHash().get(key, field);
    }

    public static void setHashMapWithExpiration(String key, HashMap<String, Integer> value, long expirationTime, TimeUnit timeUnit) {
        HashOperations<String, String, Object> hashOperations = redisTemplate.opsForHash();

        // 存储新的HashMap
        hashOperations.putAll(key, value);

        // 设置过期时间
        redisTemplate.expire(key, expirationTime, timeUnit);
    }

    public static void setHashMap(String key, Map<String, Integer> map) {
        HashOperations<String, String, Integer> hashOperations = redisTemplate.opsForHash();
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            hashOperations.put(key, entry.getKey(), entry.getValue());
        }
    }

    public static Map<String, Integer> getHashMap(String key) {
        HashOperations<String, String, Integer> hashOperations = redisTemplate.opsForHash();
        return hashOperations.entries(key);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @return Hash对象
     */
    public static Map<Object, Object> hashGetAll(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }


    /**
     * 获取多个Hash中的数据
     *
     * @param key    Redis键
     * @param fields Hash键集合
     * @return Hash对象集合
     */
    public static List<Object> hashMultiGet(final String key, final Collection<Object> fields) {
        return redisTemplate.opsForHash().multiGet(key, fields);
    }

    /**
     * 删除Hash中的数据
     *
     * @param key    Redis键
     * @param fields Hash键集合
     * @return Hash对象集合
     */
    public static long hashDeleteKeys(final String key, final Collection<Object> fields) {
        return redisTemplate.opsForHash().delete(key, fields);
    }


    /**
     * 删除Hash中的数据
     *
     * @param key    Redis键
     */
    public static long hashDeleteKey(final String key,String field) {
        return redisTemplate.opsForHash().delete(key, field);
    }

    /**
     * 针对hash的value进行增减操作
     *
     * @param key
     * @param filed
     * @param v
     */
    public static Long hashIncr(final String key,String filed,long v){
        return redisTemplate.opsForHash().increment(key,filed,v);
    }

    /**
     * 往Set中存入数据
     *
     * @param key    Redis键
     * @param values 值
     * @return 存入的个数
     */
    public static long setAdd(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 删除Set中的数据
     *
     * @param key    Redis键
     * @param values 值
     * @return 移除的个数
     */
    public static long setDel(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().remove(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 获取set中的所有对象
     *
     * @param key Redis键
     * @return set集合
     */
    public static Set<Object> getSetAll(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 往ZSet中存入数据
     *
     * @param key    Redis键
     * @param values 值
     * @return 存入的个数
     */
    public static long zsetAdd(final String key, final Set<ZSetOperations.TypedTuple<Object>> values) {
        Long count = redisTemplate.opsForZSet().add(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 设置分数，如果不存在，添加，如果存在，修改分数
     *
     * @param key
     * @param value
     * @param score
     */
    public static void zsetAdd(String key, String value, double score) {
        Boolean ret = redisTemplate.opsForZSet().addIfAbsent(key, value, score);
        if (!ret) {
            redisTemplate.opsForZSet().incrementScore(key, value, score);
        }
    }

    /**
     * 获取指定范围内，从高到低的指定个数的数据
     *
     * @param key
     * @param min   最小分数
     * @param max   最大分数
     * @param count 个数
     * @return
     */
    public static Set<ZSetOperations.TypedTuple<Object>> zsetReverseRangeWithScore(String key, double min, double max, int count) {
        return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max, 0, count);
    }


    /**
     * 删除ZSet中的数据
     *
     * @param key    Redis键
     * @param values 值
     * @return 移除的个数
     */
    public static long zsetDel(final String key, final Set<ZSetOperations.TypedTuple<Object>> values) {
        Long count = redisTemplate.opsForZSet().remove(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入数据
     *
     * @param key   Redis键
     * @param value 数据
     * @return 存入的个数
     */
    public static long listPush(final String key, final Object value) {
        Long count = redisTemplate.opsForList().rightPush(key, value);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多个数据
     *
     * @param key    Redis键
     * @param values 多个数据
     * @return 存入的个数
     */
    public static long listPushAll(final String key, final Collection<Object> values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多个数据
     *
     * @param key    Redis键
     * @param values 多个数据
     * @return 存入的个数
     */
    public static long listPushAll(final String key, final Object... values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 从List中获取begin到end之间的元素
     *
     * @param key   Redis键
     * @param start 开始位置
     * @param end   结束位置（start=0，end=-1表示获取全部元素）
     * @return List对象
     */
    public static List<Object> listGet(final String key, final int start, final int end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 生成一个默认全为false的
     * bitmapSize位的位图
     *
     * @param key
     * @param bitmapSize
     * @return
     */
    public static boolean setBitAll(final String key, final int bitmapSize) {
        try {
            for (int i = 0; i < bitmapSize; i++) {
                redisTemplate.opsForValue().setBit(key, i, false);
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }
    /**
     * 把offset设成true
     * @param key
     * @param offset
     * @return
     */
    public static boolean setBit(final String key, final int offset) {
        return  redisTemplate.opsForValue().setBit(key, offset, true);
    }


    /**
     *
     * 查询对应的key值是否创建了Bitmap
     * @param key
     * @return
     */
    public static boolean doesBitmapExist(final String key) {
        return redisTemplate.hasKey(key);
    }


    /**
     * 获取位图所有数据
     *
     * @param key
     * @param bitmapSize
     * @return true表示offset的值是1，false是0
     */

    public static List<Integer> getBitAll(final String key, final int bitmapSize) {
        List<Integer> list = new ArrayList<>();
        try {
            for (int i = 0; i < bitmapSize; i++) {
                Boolean bit = redisTemplate.opsForValue().getBit(key, i);
                list.add(Boolean.TRUE.equals(bit) ?1:0);
            }
        } catch (Exception e) {
            throw new RuntimeException("报错了啊，哥们");
        }
        return list;
    }
    /**
     * 获取位图数据
     *
     * @param key
     * @param offset
     * @return true表示offset的值是1，false是0
     */
    public static boolean getBit(final String key, final int offset) {
        return redisTemplate.opsForValue().getBit(key, offset);
    }

    /**
     * bitfield命令获取指定范围的bit位的数据
     *
     * RestTemplate提供的biField()方法，可以一次性获取多个范围的数据，所以返回的是列表
     *
     * @param key
     * @param limit
     * @param offset
     * @return
     */
    public static Long bitfield(final String key, int limit, long offset) {
        List<Long> list =  redisTemplate
                .opsForValue()
                .bitField(key, BitFieldSubCommands.create()
                        .get(BitFieldSubCommands.BitFieldType.unsigned(limit))
                        .valueAt(offset));

        if(list != null && list.size() > 0){
            return list.get(0);
        }else {
            return null;
        }
    }
    /**
     * 医生签约人数管理
     *
     * @param doctorId 医生ID
     * @return 当前签约人数
     */
    public static long getDoctorSignupCount(String doctorId) {
        String key = "doctor:" + doctorId + ":signups";
        return redisTemplate.opsForValue().increment(key, -1); // 获取当前值并减少1，因为Redis中初始值是0
    }
    /**
     * 用户尝试签约医生
     *
     * @param doctorId 医生ID
     * @param userId
     @return 签约成功与否 */
    public static boolean trySignUpDoctor(String doctorId,String userId) {
        String key = "doctor:"+doctorId + ":signups";
        String userKey = "user:"+userId + ":doctor:"+doctorId;
//        //检查医生是否已满额
//        long signupCount = getDoctorSignupCount(doctorId);
//        if (signupCount >= 10) {
//            return false; // 医生已满额，无法签约
//        }

        // 检查用户是否已签约
        if (redisTemplate.opsForValue().get(userKey) != null) {
            throw new RuntimeException("用户已签约，无法重复签约");
        }

        try {
            if (redisTemplate.opsForValue().get(userKey)==null){
                redisTemplate.opsForValue().set(userKey,1);
            }else {
                // 增加医生签约人数
                redisTemplate.opsForValue().increment(key);
            }


            // 设置用户签约记录，过期时间为1年
            redisTemplate.opsForValue().set(userKey, userId, SignEnum.SIGN_ENUM_TimeOut.timeout, TimeUnit.DAYS);

            redisTemplate.expire(key, -1, TimeUnit.DAYS);
        } catch (Exception e) {
            throw new RuntimeException("签约异常,请联系客服");
        }

        return true; // 签约成功
    }
    /**
     处理医生签约人数键过期事件
     @param doctorId 医生ID */
    public static void handleDoctorSignupKeyExpired(String doctorId){
        String key = "doctor:" + doctorId + ":signups";// 获取当前签约人数
        long signupCount = getDoctorSignupCount(doctorId);// 如果签约人数大于0，减少1
        if (signupCount > 0) {
            redisTemplate.opsForValue().decrement(key);
        }
    }

}

